<html>
<head><meta charset="utf-8"><title>investigating obligations blowup · wg-traits · Zulip Chat Archive</title></head>
<h2>Stream: <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/index.html">wg-traits</a></h2>
<h3>Topic: <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html">investigating obligations blowup</a></h3>

<hr>

<base href="https://rust-lang.zulipchat.com">

<head><link href="https://rust-lang.github.io/zulip_archive/style.css" rel="stylesheet"></head>

<a name="204946293"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/204946293" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Izzy Swart <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#204946293">(Jul 24 2020 at 17:49)</a>:</h4>
<p>Hey, I filed <a href="https://github.com/rust-lang/rust/issues/74456">https://github.com/rust-lang/rust/issues/74456</a> a short while back after some discussion at <a href="#narrow/stream/182449-t-compiler.2Fhelp/topic/debugging.20rustc.20OOM">https://rust-lang.zulipchat.com/#narrow/stream/182449-t-compiler.2Fhelp/topic/debugging.20rustc.20OOM</a>. I'm sorry if this is the wrong place to ask for further assistance but I'd like to find someone intimately familiar with the trait solver internals who might be able to point me toward methodology for investigating this issue, as there hasn't been any momentum on it recently. It's understandably not a priority for others given that I appear to be the only one to have encountered it but it's blocking my research and I would simply like some advice if possible such that I might continue investigating it independently and contribute my findings at such a point as I become able to determine the root cause of the issue.</p>
<p>My main question is something tangentially mentioned in the issue: how do I figure out what the obligations are that are occupying this data structure? How do I figure out what higher-level query is responsible for this (at a level more granular than the top-level info provided by -Zself-profile)? How do I determine whether the function is being called a few times with a large obligation set or many, many times with smaller sets of obligations? Are there any deduplication steps before this function is called?</p>
<p>The only way I currently have to investigate this issue is attempting to read meaning into the soup of <code>def_ids</code> output by <code>RUSTC_LOG</code> or maybe running the compiler itself in a debugger, but neither approach gets me what I need. I guess I could recompile the debugger with extra prints to export the obligations to a file, but even for my smaller reproductions the size of that vector is multiple <em>gigabytes</em>, so I'm not sure how feasible that is, and the iteration time would be absurdly long what with having to recompile rustc. How do people usually investigate things like this?</p>



<a name="205270180"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/205270180" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Wesley Wiser <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#205270180">(Jul 28 2020 at 18:08)</a>:</h4>
<p><span class="user-mention" data-user-id="116118">@Matthew Jasper</span> Do you have any ideas about how to debug this issue?</p>



<a name="205270435"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/205270435" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Wesley Wiser <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#205270435">(Jul 28 2020 at 18:10)</a>:</h4>
<p>I'm not very familiar with the trait system code so I think the two main things that would be helpful are:</p>
<ol>
<li>What's the usual workflow for debugging issues with the trait system code?</li>
<li>How can we figure out why the obligation vector is so large (multiple gigabytes)?</li>
</ol>



<a name="206206780"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/206206780" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Izzy Swart <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#206206780">(Aug 06 2020 at 22:48)</a>:</h4>
<p><span class="user-mention" data-user-id="125250">@Wesley Wiser</span>  at this point I <em>think</em> what's happening is that normalization generates a bunch of extra obligations. i'm getting output for example "with 885017 obligations" from here: <a href="https://doc.rust-lang.org/nightly/nightly-rustc/src/rustc_trait_selection/traits/project.rs.html#270">https://doc.rust-lang.org/nightly/nightly-rustc/src/rustc_trait_selection/traits/project.rs.html#270</a></p>
<p>presumably, after that happens the previously investigated source (<a href="https://github.com/rust-lang/rust/blob/7e11379f3b4c376fbb9a6c4d44f3286ccc28d149/src/librustc_trait_selection/traits/select/mod.rs#L2053">https://github.com/rust-lang/rust/blob/7e11379f3b4c376fbb9a6c4d44f3286ccc28d149/src/librustc_trait_selection/traits/select/mod.rs#L2053</a>) is executed in order to deduplicate the obligation vec. i've been messing around with RUSTC_LOG and have noticed that the actual process of generating those obligations is pretty quick but after each execution of normalize_with_depth_to the compiler takes longer and longer to process the next iteration, presumably due to time spent deduplicating (as I earlier ascertained that doing so is a substantial portion of the CPU time spent, in the other thread in <a class="stream" data-stream-id="182449" href="/#narrow/stream/182449-t-compiler.2Fhelp">#t-compiler/help</a>. it does seem like the amount of time spent deduplicating is nonlinear over the number of obligations generated, which doesn't make sense to me given that it's just inserting them all into a hashset, but I'm not sure. this output from projection is consistent with the most recent update from on the issue (<a href="https://github.com/rust-lang/rust/issues/74456#issuecomment-668638113">https://github.com/rust-lang/rust/issues/74456#issuecomment-668638113</a>), courtesy of <span class="user-mention" data-user-id="318582">@Denis Lisov</span>, which also confirms that the vast majority of the obligations produced are redundant</p>
<p>what needs to happen I suppose is some sort of deduplication of the accumulated obligations during normalization <strong>during that process</strong> as opposed to after the fact. I don't know what the best path is to do that: I don't know whether storing them all in an FxHashSet in the first place is feasible (maybe some duplicates are actually necessary? i seem to remember seeing some comments about ordering guarantees, how does that impact potential deduplication strategies? etc.) and I'm not sure what the compiler's general design philosophy requires for this to be implemented elegantly and soundly</p>
<p>so I guess at this point I'm in need of </p>
<ul>
<li>confirmation of whether my assessment of the problem is correct</li>
<li>confirmation of whether my assumption that earlier deduplication is the best (most feasible &amp; efficient) strategy as opposed to some higher-level algorithmic improvement</li>
<li>guidance on how to implement something of the sort without interfering with guarantees of which I might be unaware or causing other problems</li>
</ul>



<a name="206262870"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/206262870" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Wesley Wiser <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#206262870">(Aug 07 2020 at 14:24)</a>:</h4>
<p><span class="user-mention" data-user-id="266752">@Izzy Swart</span> </p>
<blockquote>
<p>I don't know whether storing them all in an FxHashSet in the first place is feasible (maybe some duplicates are actually necessary? i seem to remember seeing some comments about ordering guarantees, how does that impact potential deduplication strategies? etc.)</p>
</blockquote>
<p>That seems like a reasonable idea to me. I suspect you'll quickly discover if that's feasible or not when the rustc bootstrap completes or ICEs. Assuming it works, iirc, this code has been pretty heavily optimized by <span class="user-mention" data-user-id="120989">@njn</span> and I think there's special handling somewhere for 0 or 1 obligations which are extremely common. So it may not be as simple as just changing this to use a <code>FxHashSet</code>, we may need some kind of hybrid data structure that avoids the hashing overhead for 1 element collections. If deduplicating along the way works, we can probably solve any performance concerns once we can run the modified compiler on the <a href="http://perf.rust-lang.org">perf.rust-lang.org</a> infrastructure.</p>



<a name="206299801"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/206299801" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Izzy Swart <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#206299801">(Aug 07 2020 at 19:28)</a>:</h4>
<p>definitely seems like there are some ordering guarantees, replacing a bunch of the predicate vecs with hashsets ends up giving me an "encountered ambiguity" ICE while trying to build the stage1 standard library</p>
<p>full error:</p>
<div class="codehilite"><pre><span></span><code>error: internal compiler error: encountered ambiguity selecting `Binder(&lt;iter::adapters::fuse::Fuse&lt;iter::adapters::Map&lt;str::Chars, str::CharEscapeUnicode&gt;&gt; as iter::adapters::fuse::FuseImpl&lt;iter::adapters::Map&lt;str::Chars, str::CharEscapeUnicode&gt;&gt;&gt;)` during codegen, presuming due to overflow or prior type error
</code></pre></div>


<p>definitely need to talk to someone who knows what guarantees are important for these data structures</p>
<p>seems like the ordering <a href="https://github.com/rust-lang/rust/blob/76e83339bb619aba206e5590b1e4b813a154b199/src/librustc_trait_selection/traits/wf.rs#L251">https://github.com/rust-lang/rust/blob/76e83339bb619aba206e5590b1e4b813a154b199/src/librustc_trait_selection/traits/wf.rs#L251</a> here is important at the very least, things are being deliberately inserted at a specific point</p>



<a name="206301976"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/206301976" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Wesley Wiser <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#206301976">(Aug 07 2020 at 19:50)</a>:</h4>
<p>Just to see if it helps the issue you're running into, could you keep the sorted vector around and also a <code>FxHashSet</code> and then only append to the vector if it's not already in the hash set? I guess if the duplicates are actually needed then that won't work.</p>



<a name="213123919"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/213123919" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Tatsuyuki Ishi <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#213123919">(Oct 13 2020 at 08:19)</a>:</h4>
<p>Hey, sorry for bumping this old thread, but I just saw this and I wanted to share that the majority of obligation duplication can be avoided with <a href="https://github.com/rust-lang/rust/pull/77325">https://github.com/rust-lang/rust/pull/77325</a>. I'm not sure if the PR's approach is fully sound and I still have several thing related to associated type defaults to fix, but I think this should be related to your question and might be useful.</p>



<a name="213853083"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/213853083" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nikomatsakis <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#213853083">(Oct 19 2020 at 22:13)</a>:</h4>
<p>I've been looking at that PR <span class="user-mention" data-user-id="117366">@Tatsuyuki Ishi</span> and indeed i'm not yet sure what to think :)</p>



<a name="213853090"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/213853090" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nikomatsakis <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#213853090">(Oct 19 2020 at 22:13)</a>:</h4>
<p>I need to carve out a bit more time I guess to study it</p>



<a name="213853204"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/213853204" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nikomatsakis <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#213853204">(Oct 19 2020 at 22:15)</a>:</h4>
<p>I remember that fixing a very subtle problem</p>



<a name="213853233"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/213853233" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nikomatsakis <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#213853233">(Oct 19 2020 at 22:15)</a>:</h4>
<p>(<a href="https://github.com/rust-lang/rust/issues/43132">https://github.com/rust-lang/rust/issues/43132</a>)</p>



<a name="218043589"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/218043589" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Izzy Swart <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#218043589">(Nov 26 2020 at 22:52)</a>:</h4>
<p>I've been busy with school and haven't had the chance to try implementing any of the fixes I discussed back in July/August, but I'm going to try building <span class="user-mention" data-user-id="117366">@Tatsuyuki Ishi</span>'s fork with the deduplication logic reverted to see if that helps. I don't fully understand the reason the duplicates were being produced in the first place, but I'll look over the logic mentioned in some of the linked commits.</p>



<a name="218058853"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/218058853" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Izzy Swart <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#218058853">(Nov 27 2020 at 05:57)</a>:</h4>
<p>still runs out of memory in the same way, that didn't solve the issue. I have a break (for about a month) coming up in a week or so, and hopefully I can dedicate some time to investigating this.</p>



<a name="219668513"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/219668513" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Izzy Swart <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#219668513">(Dec 11 2020 at 22:06)</a>:</h4>
<p>well, a correction to my previous note is in order. The repro crate I used to demonstrate the issue initially now builds successfully on <span class="user-mention" data-user-id="117366">@Tatsuyuki Ishi</span>'s branch and just on stable rustc, but the actual project I was working on that I was attempting to minimize with that demonstration still doesn't work (OOMs). I think it might be related to <a href="https://github.com/rust-lang/rust/issues/70513">https://github.com/rust-lang/rust/issues/70513</a>, but unlike that issue it persists when the relevant use-site is fully annotated. It's similar in that the bug is only exercised by body checking of the function which monomorphizes the type and not any definition-site.</p>



<a name="221181505"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/221181505" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Izzy Swart <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#221181505">(Dec 30 2020 at 01:04)</a>:</h4>
<p><span class="user-mention" data-user-id="125250">@Wesley Wiser</span> well, I finally have a reproduction that doesn't incorporate any external dependencies after a bit of work over the past week or so. <a href="https://github.com/syntacticsugarglider/rustc-bug-mcve">https://github.com/syntacticsugarglider/rustc-bug-mcve</a>. It compiles fine (almost instantly) if the nesting depth on this Test type is reduced: <a href="https://github.com/syntacticsugarglider/rustc-bug-mcve/blob/main/src/lib.rs#L135">https://github.com/syntacticsugarglider/rustc-bug-mcve/blob/main/src/lib.rs#L135</a> or if it's bounded on any other trait than the Unravel trait adapted from <code>protocol</code>.  I picked an arbitrary amount of nesting that will exceed system memory limits and get SIGKILL'd on every machine I have access to, but much shallower degrees of nesting are still sufficient to cause exceedingly long compilation times and use gigabytes of memory. This could definitely use further minimization, but in my cursory efforts to do so the removal of a variety of seemingly unrelated constraints (unrelated to the StreamError parameter that seems causative as mentioned below) ends up resolving the problem and causing reproduction to fail (i.e. it compiles expediently).</p>
<p>I have a bunch of notes that probably reflect  a lot of fundamental misunderstandings about how the trait solver works here, but I've found it difficult to clarify my understanding much beyond procedurally working through the control flow of the relevant bits of the compiler source as the documentation (in the compiler book etc) is pretty sparse and high-level: <a href="https://docs.google.com/document/d/1oYcjLCgtHrML7l0vh6wWzS_cWOb7RbAUmQV2W70cFTM/edit?usp=sharing">https://docs.google.com/document/d/1oYcjLCgtHrML7l0vh6wWzS_cWOb7RbAUmQV2W70cFTM/edit?usp=sharing</a><br>
The more recent information is toward the end of the document, and the gist of the issue seems to be that there's an immense duplication of obligations that occurs with the variance being sp. over an inference variable that is always in the same position, that being the second type parameter of the Transport struct from protocol-mve-transport, which in the simplified reproduction is the first parameter: <a href="https://github.com/syntacticsugarglider/rustc-bug-mcve/blob/main/src/lib.rs#L137">https://github.com/syntacticsugarglider/rustc-bug-mcve/blob/main/src/lib.rs#L137</a>. This is quite reminiscent of <a href="https://github.com/rust-lang/rust/issues/70513">https://github.com/rust-lang/rust/issues/70513</a>, but instead the problem arises during typechecking (both initially and during the second MIR typecheck) while selecting candidates for that root predicate (the : Unravel one) instead of inference. I'm also not really sure how relevant this even is to <a href="https://github.com/rust-lang/rust/issues/74456">https://github.com/rust-lang/rust/issues/74456</a>, as <span class="user-mention" data-user-id="117366">@Tatsuyuki Ishi</span>'s changes seem to have remedied that to a degree, the original reproduction used in that issue now compiles successfully.</p>
<p>This is reproducible on current stable, nightly, and Ishi's fork with deduplication etc. removed (<a href="https://github.com/ishitatsuyuki/rust/tree/nodup">https://github.com/ishitatsuyuki/rust/tree/nodup</a>). </p>
<p>This is long and sort of rambling and incoherent, I've collected rather a lot of information about this problem and don't have the generalized domain knowledge to put it all together so the relative lack of structure here reflects the lack of cognitive structure I've managed to apply to this issue. Let me know if any clarification is in order or if there's anything I should work on other than further minimization. Any further information, especially on why that type variable is being duplicated, would be exceedingly welcome, incl. information as to why there's an inference variable there in the first place as, as far as I can tell, everything is fully annotated &amp; specified. Moreover, I'm not sure what should happen to those two existing issues, because I'm not exactly sure what their precise relationship is to the current state of things.</p>



<a name="221182965"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/221182965" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Wesley Wiser <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#221182965">(Dec 30 2020 at 01:39)</a>:</h4>
<p>Thanks for the excellent minimization and investigation! Unfortunately, this is well outside of my knowledge of the type checker. Perhaps <span class="user-mention" data-user-id="116009">@nikomatsakis</span> has an idea of what the next step to investigate here would be? (Or at least, who else should be looped in for questions?) </p>
<p>Having read your document, I'm also a bit confused by the naming of <code>fn vtables_impl()</code> as it doesn't seem to have anything to do with virtual function calls, just trait implementations. If my git blame is to be believed, this function was originally added a very long time ago:</p>
<div class="codehilite"><pre><span></span><code>commit 389ef6601d18112a7a449eac2e190e4eb061bdf8
Author: Niko Matsakis &lt;niko@alum.mit.edu&gt;
Date:   Thu Oct 9 17:19:50 2014 -0400

    Implement multidispatch and conditional dispatch. Because we do not
    attempt to preserve crate concatenation, this is a backwards compatible
    change.
</code></pre></div>
<p>Perhaps the name refers to a time when trait methods were always dynamically dispatched or something?</p>



<a name="221183220"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/221183220" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Izzy Swart <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#221183220">(Dec 30 2020 at 01:45)</a>:</h4>
<p>yeah I'm frankly not sure what's up with that call or its name, but thankfully it didn't end up being crucial to my investigation. the relevant duplication  seems to be carried over wherever those normalization-implied obligations are concerned, so any query entry-point that's involved in one of those processes is quite sufficient. for what it's worth I also have Massif and -Zself-profile data for these reproductions, but I'm not sure that's really helpful now that the hotspots are identified any the specific cause is somewhat more nailed down (the duplication over inference variables). Do let me know if they're useful, I can provide them.</p>



<a name="221183341"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/221183341" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Izzy Swart <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#221183341">(Dec 30 2020 at 01:49)</a>:</h4>
<p><span class="user-mention" data-user-id="318582">@Denis Lisov</span> i remember you contributing to the initial investigation of this issue some months ago, so perhaps this would interest you?</p>



<a name="221201088"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/221201088" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#221201088">(Dec 30 2020 at 09:36)</a>:</h4>
<p>vtables is the previous name for <a href="https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/traits/select/enum.SelectionCandidate.html">https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/traits/select/enum.SelectionCandidate.html</a> and was really confusing <span aria-label="laughing" class="emoji emoji-1f606" role="img" title="laughing">:laughing:</span> we probably should rename <code>vtable_impl</code> to something like <code>instantiate_impl</code></p>



<a name="221208721"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/221208721" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Denis Lisov <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#221208721">(Dec 30 2020 at 12:21)</a>:</h4>
<p><span class="user-mention silent" data-user-id="266752">Izzy Swart</span> Practicing nerd sniping? :-) I know next to nothing about the rustc internals, and it looks like you've already collected all the info a profiler could help you extract... so I might be able to look at this in the next couple weeks, but at the moment you're way ahead of me and have more background than me.</p>



<a name="221247976"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/221247976" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Izzy Swart <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#221247976">(Dec 30 2020 at 21:27)</a>:</h4>
<p><span class="user-mention silent" data-user-id="318582">Denis Lisov</span> <a href="#narrow/stream/144729-wg-traits/topic/investigating.20obligations.20blowup/near/221208721">said</a>:</p>
<blockquote>
<p><span class="user-mention silent" data-user-id="266752">Izzy Swart</span> Practicing nerd sniping? :-) I know next to nothing about the rustc internals, and it looks like you've already collected all the info a profiler could help you extract... so I might be able to look at this in the next couple weeks, but at the moment you're way ahead of me and have more background than me.</p>
</blockquote>
<p>Oops, alright. Thought you had relevant background since you posted some relevant debug info on one of the old issue submissions, and I thus assumed this would also be of interest. Feel free to disregard :)</p>



<a name="222940378"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/222940378" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Izzy Swart <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#222940378">(Jan 15 2021 at 23:24)</a>:</h4>
<p>looking through the blame and given that niko appears to be busy perhaps <span class="user-mention" data-user-id="116118">@Matthew Jasper</span> or <span class="user-mention" data-user-id="219477">@Markus Westerlind</span> might have some input on this?</p>



<a name="222940727"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/222940727" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Izzy Swart <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#222940727">(Jan 15 2021 at 23:28)</a>:</h4>
<p>or perhaps <span class="user-mention" data-user-id="216206">@lcnr</span> i suppose, but maybe not given that they've already clarified something but didn't comment further.</p>



<a name="222940784"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/222940784" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#222940784">(Jan 15 2021 at 23:29)</a>:</h4>
<p>i would have to look deeper into this myself</p>



<a name="222940888"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/222940888" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#222940888">(Jan 15 2021 at 23:30)</a>:</h4>
<p>don't have a lot of time rn so I probably won't make time for this this weekend</p>



<a name="222941069"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/222941069" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#222941069">(Jan 15 2021 at 23:33)</a>:</h4>
<p>will try to get to it next week but can't promise anything here</p>



<a name="222941161"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/222941161" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Izzy Swart <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#222941161">(Jan 15 2021 at 23:34)</a>:</h4>
<p>dw, i realize that this probably isn't a priority given that it seems i'm more or less the only one who has managed to exercise the issue to any substantive degree and there's active redesign work happening on the trait solver regardless. if i had more info i would try to fix it myself given that i've been blocked on this for like 6mo, so anything is useful tbh.</p>



<a name="222941263"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/222941263" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Izzy Swart <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#222941263">(Jan 15 2021 at 23:36)</a>:</h4>
<p>do you know if there's a resource on the process by which inference variables are generated and resolved? that's the part I'm most confused about, and it seems the most causative: the duplication occurs over seemingly identical inference variables in position of an explicitly annotated concrete type, and it's that duplication that results in the absurd memory usage.</p>



<a name="222944600"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/222944600" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#222944600">(Jan 16 2021 at 00:22)</a>:</h4>
<p>hmm, not sure <span aria-label="thinking" class="emoji emoji-1f914" role="img" title="thinking">:thinking:</span> probably have to look at AstConv directly or something <span aria-label="thinking" class="emoji emoji-1f914" role="img" title="thinking">:thinking:</span></p>



<a name="222951428"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/222951428" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jack Huey <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#222951428">(Jan 16 2021 at 02:02)</a>:</h4>
<p>Fwiw, I'll try to reread what's the issue here and maybe give feedback this weekend. Even though I'm not super familiar with rustc's trait solver, nor can I do an official review, might be able to give feedback.</p>



<a name="223023185"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/223023185" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Izzy Swart <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#223023185">(Jan 17 2021 at 04:16)</a>:</h4>
<p><span class="user-mention silent" data-user-id="232957">Jack Huey</span> <a href="#narrow/stream/144729-wg-traits/topic/investigating.20obligations.20blowup/near/222951428">said</a>:</p>
<blockquote>
<p>Fwiw, I'll try to reread what's the issue here and maybe give feedback this weekend. Even though I'm not super familiar with rustc's trait solver, nor can I do an official review, might be able to give feedback.</p>
</blockquote>
<p>Thanks, I appreciate it. Let me know if you have any questions.</p>



<a name="224974100"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/224974100" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Izzy Swart <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#224974100">(Feb 03 2021 at 05:07)</a>:</h4>
<p>did anyone here have a chance to take a look at this over the past couple weeks?</p>



<a name="224992893"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/224992893" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#224992893">(Feb 03 2021 at 09:42)</a>:</h4>
<p>i did not, partially because i didn't have much time and partially cause it slipped my mind</p>



<a name="224992903"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/224992903" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#224992903">(Feb 03 2021 at 09:42)</a>:</h4>
<p>can do so today</p>



<a name="224997987"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/224997987" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#224997987">(Feb 03 2021 at 10:37)</a>:</h4>
<p>so, let me write down my current understanding</p>



<a name="224998006"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/224998006" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#224998006">(Feb 03 2021 at 10:37)</a>:</h4>
<p>to get the blowup we can also use</p>
<div class="codehilite" data-code-language="Rust"><pre><span></span><code><span class="k">fn</span> <span class="nf">tester</span><span class="o">&lt;</span><span class="n">P</span>: <span class="nc">Unravel</span><span class="o">&lt;</span><span class="n">Transport</span><span class="o">&lt;</span><span class="kt">i32</span><span class="p">,</span><span class="w"> </span><span class="n">Infallible</span><span class="p">,</span><span class="w"> </span><span class="n">P</span><span class="o">&gt;&gt;&gt;</span><span class="p">()</span><span class="w"> </span><span class="p">{}</span><span class="w"></span>
<span class="k">const</span><span class="w"> </span><span class="n">FOO</span>: <span class="nc">fn</span><span class="p">()</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">tester</span>::<span class="o">&lt;</span><span class="n">Test</span><span class="o">&gt;</span><span class="p">;</span><span class="w"></span>
</code></pre></div>



<a name="224998082"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/224998082" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#224998082">(Feb 03 2021 at 10:38)</a>:</h4>
<p>so it happens while trying to prove <code>&lt;Test as Unravel&lt;Transport&lt;i32, Infallible, P&gt;&gt;&gt;</code></p>



<a name="225004509"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/225004509" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#225004509">(Feb 03 2021 at 11:48)</a>:</h4>
<p>further minimized <a href="https://play.rust-lang.org/?version=stable&amp;mode=debug&amp;edition=2018&amp;gist=5328c925c52f233261ffc408d73d7131">https://play.rust-lang.org/?version=stable&amp;mode=debug&amp;edition=2018&amp;gist=5328c925c52f233261ffc408d73d7131</a></p>



<a name="225009577"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/225009577" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#225009577">(Feb 03 2021 at 12:45)</a>:</h4>
<p>further minimized:</p>
<div class="codehilite" data-code-language="Rust"><pre><span></span><code><span class="k">use</span><span class="w"> </span><span class="n">std</span>::<span class="n">marker</span>::<span class="n">PhantomData</span><span class="p">;</span><span class="w"></span>

<span class="k">trait</span><span class="w"> </span><span class="n">Future</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
<span class="w">    </span><span class="k">type</span> <span class="nc">FutAssoc</span><span class="p">;</span><span class="w"></span>
<span class="p">}</span><span class="w"></span>
<span class="k">trait</span><span class="w"> </span><span class="n">Unravel</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
<span class="w">    </span><span class="k">type</span> <span class="nc">UnravelAssoc</span>: <span class="nc">Future</span><span class="o">&lt;</span><span class="n">FutAssoc</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">DontCare</span><span class="o">&gt;</span><span class="p">;</span><span class="w"></span>
<span class="p">}</span><span class="w"></span>
<span class="k">struct</span> <span class="nc">MapErr</span><span class="o">&lt;</span><span class="n">Fut</span><span class="p">,</span><span class="w"> </span><span class="n">F</span><span class="o">&gt;</span><span class="p">(</span><span class="n">PhantomData</span><span class="o">&lt;</span><span class="p">(</span><span class="n">Fut</span><span class="p">,</span><span class="w"> </span><span class="n">F</span><span class="p">)</span><span class="o">&gt;</span><span class="p">);</span><span class="w"></span>
<span class="k">impl</span><span class="o">&lt;</span><span class="n">E</span><span class="p">,</span><span class="w"> </span><span class="n">Fut</span><span class="p">,</span><span class="w"> </span><span class="n">F</span><span class="o">&gt;</span><span class="w"> </span><span class="n">Future</span><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">MapErr</span><span class="o">&lt;</span><span class="n">Fut</span><span class="p">,</span><span class="w"> </span><span class="n">F</span><span class="o">&gt;</span><span class="w"></span>
<span class="k">where</span><span class="w"></span>
<span class="w">    </span><span class="n">Fut</span>: <span class="nc">Future</span><span class="p">,</span><span class="w"></span>
<span class="w">    </span><span class="c1">// this requires us to normalize `FutAssoc`??</span>
<span class="w">    </span><span class="n">F</span>: <span class="nb">FnMut</span><span class="p">(</span><span class="n">Fut</span>::<span class="n">FutAssoc</span><span class="p">)</span><span class="w"> </span>-&gt; <span class="nc">E</span><span class="p">,</span><span class="w"></span>
<span class="p">{</span><span class="w"></span>
<span class="w">    </span><span class="k">type</span> <span class="nc">FutAssoc</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">E</span><span class="p">;</span><span class="w"></span>
<span class="p">}</span><span class="w"></span>

<span class="k">impl</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="n">Unravel</span><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="n">T</span><span class="p">,)</span><span class="w"></span>
<span class="k">where</span><span class="w"></span>
<span class="w">    </span><span class="n">T</span>: <span class="nc">Unravel</span><span class="p">,</span><span class="w"></span>
<span class="w">    </span><span class="o">&lt;</span><span class="n">T</span><span class="w"> </span><span class="k">as</span><span class="w"> </span><span class="n">Unravel</span><span class="o">&gt;</span>::<span class="n">UnravelAssoc</span>: <span class="p">,</span><span class="w"></span>
<span class="w">    </span><span class="c1">//^ somehow this empty where clause is required???</span>
<span class="w">    </span><span class="c1">// so i guess we normalize T as Unravel&lt;C&gt; twice here and are somehow unable to</span>
<span class="w">    </span><span class="c1">// cache the result :thinking:</span>
<span class="p">{</span><span class="w"></span>
<span class="w">    </span><span class="k">type</span> <span class="nc">UnravelAssoc</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">MapErr</span><span class="o">&lt;</span><span class="w"></span>
<span class="w">        </span><span class="o">&lt;</span><span class="n">T</span><span class="w"> </span><span class="k">as</span><span class="w"> </span><span class="n">Unravel</span><span class="o">&gt;</span>::<span class="n">UnravelAssoc</span><span class="p">,</span><span class="w"></span>
<span class="w">        </span><span class="k">fn</span><span class="p">(</span><span class="o">&lt;&lt;</span><span class="n">T</span><span class="w"> </span><span class="k">as</span><span class="w"> </span><span class="n">Unravel</span><span class="o">&gt;</span>::<span class="n">UnravelAssoc</span><span class="w"> </span><span class="k">as</span><span class="w"> </span><span class="n">Future</span><span class="o">&gt;</span>::<span class="n">FutAssoc</span><span class="p">)</span><span class="w"> </span>-&gt; <span class="nc">DontCare</span><span class="p">,</span><span class="w"></span>
<span class="w">    </span><span class="o">&gt;</span><span class="p">;</span><span class="w"></span>
<span class="p">}</span><span class="w"></span>

<span class="k">struct</span> <span class="nc">FutureTy</span><span class="p">;</span><span class="w"></span>
<span class="k">struct</span> <span class="nc">DontCare</span><span class="p">;</span><span class="w"></span>
<span class="k">impl</span><span class="w"> </span><span class="n">Future</span><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">FutureTy</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
<span class="w">    </span><span class="k">type</span> <span class="nc">FutAssoc</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">DontCare</span><span class="p">;</span><span class="w"></span>
<span class="p">}</span><span class="w"></span>
<span class="k">impl</span><span class="w"> </span><span class="n">Unravel</span><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
<span class="w">    </span><span class="k">type</span> <span class="nc">UnravelAssoc</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">FutureTy</span><span class="p">;</span><span class="w"></span>
<span class="p">}</span><span class="w"></span>

<span class="c1">// This has a runtime of O(2^n)</span>
<span class="fm">macro_rules!</span><span class="w"> </span><span class="n">nested</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
<span class="w">    </span><span class="p">()</span><span class="w"> </span><span class="o">=&gt;</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="p">()</span><span class="w"> </span><span class="p">};</span><span class="w"></span>
<span class="w">    </span><span class="p">(.</span><span class="w"> </span><span class="cp">$($t</span>:<span class="nc">tt</span><span class="p">)</span><span class="o">*</span><span class="p">)</span><span class="w"> </span><span class="o">=&gt;</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
<span class="w">        </span><span class="p">(</span><span class="n">nested</span><span class="o">!</span><span class="p">(</span><span class="cp">$($t</span><span class="p">)</span><span class="o">*</span><span class="p">),)</span><span class="w"></span>
<span class="w">    </span><span class="p">}</span><span class="w"></span>
<span class="p">}</span><span class="w"></span>
<span class="k">type</span> <span class="nc">Test</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">nested</span><span class="o">!</span><span class="p">(</span><span class="w"></span>
<span class="w">    </span><span class="p">.</span><span class="w"> </span><span class="p">.</span><span class="w"> </span><span class="p">.</span><span class="w"> </span><span class="p">.</span><span class="w"> </span><span class="p">.</span><span class="w"></span>
<span class="w">    </span><span class="p">.</span><span class="w"> </span><span class="p">.</span><span class="w"> </span><span class="p">.</span><span class="w"> </span><span class="p">.</span><span class="w"> </span><span class="p">.</span><span class="w"></span>
<span class="w">    </span><span class="p">.</span><span class="w"> </span><span class="p">.</span><span class="w"> </span><span class="p">.</span><span class="w"> </span><span class="p">.</span><span class="w"> </span><span class="p">.</span><span class="w"></span>
<span class="w">    </span><span class="p">.</span><span class="w"> </span><span class="p">.</span><span class="w"> </span><span class="p">.</span><span class="w"> </span><span class="p">.</span><span class="w"> </span><span class="p">.</span><span class="w"></span>
<span class="w">    </span><span class="p">.</span><span class="w"> </span><span class="p">.</span><span class="w"></span>
<span class="p">);</span><span class="w"></span>
<span class="k">fn</span> <span class="nf">tester</span><span class="o">&lt;</span><span class="n">P</span>: <span class="nc">Unravel</span><span class="o">&gt;</span><span class="p">()</span><span class="w"> </span><span class="p">{}</span><span class="w"></span>
<span class="k">fn</span> <span class="nf">main</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
<span class="w">    </span><span class="n">tester</span>::<span class="o">&lt;</span><span class="n">Test</span><span class="o">&gt;</span><span class="p">();</span><span class="w"></span>
<span class="p">}</span><span class="w"></span>
</code></pre></div>



<a name="225009830"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/225009830" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#225009830">(Feb 03 2021 at 12:48)</a>:</h4>
<p>that's where i stop for now, still don't get why it only fails with pretty much this exact setup</p>



<a name="225009872"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/225009872" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#225009872">(Feb 03 2021 at 12:48)</a>:</h4>
<p>probably missing some optimization we do when normalizing associated types</p>



<a name="225009914"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/225009914" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#225009914">(Feb 03 2021 at 12:49)</a>:</h4>
<p>cause from what i can tell applying <code>impl&lt;T&gt; Unravel for (T,)</code> for a nested tuple</p>



<a name="225009944"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/225009944" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#225009944">(Feb 03 2021 at 12:49)</a>:</h4>
<p>should create exponentially many obligations even without using <code>MapErr</code></p>



<a name="228638007"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/228638007" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jonathan de Jong <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#228638007">(Mar 03 2021 at 18:04)</a>:</h4>
<p><span class="user-mention silent" data-user-id="216206">lcnr</span> <a href="#narrow/stream/144729-wg-traits/topic/investigating.20obligations.20blowup/near/225009872">said</a>:</p>
<blockquote>
<p>probably missing some optimization we do when normalizing associated types</p>
</blockquote>
<p>I'm currently poking at the compiler, and i notice that the <code>&lt;T as Unravel&gt;::UnravelAssoc</code> gets placed in a special <code>outlives_predicates</code> variable.</p>
<p>The comment <a href="https://github.com/rust-lang/rust/blob/c4b90dfdc53882e139a2ca18ecc0cbadf56a1e40/compiler/rustc_trait_selection/src/traits/mod.rs#L308-L325">just above</a> also clarifies;</p>
<blockquote>
<p>Inferred outlives bounds can create a lot of <code>TypeOutlives</code> predicates for associated types, so to make the situation less bad, we normalize all the predicates <em>but</em> the <code>TypeOutlives</code> predicates first inside the unnormalized parameter environment, and then we normalize the <code>TypeOutlives</code> bounds inside the normalized parameter environment.</p>
</blockquote>
<p>I'm still early and green in my "how does rust work" journey, and i'm taking a metaphorical sledgehammer at trying to understand this, but i have the feeling that this is causing the implicit predicate to be excluded from optimizations, and somehow recursively/exponentially "solved" for every nesting in <code>((((),),),)...</code></p>



<a name="228638925"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/228638925" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jonathan de Jong <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#228638925">(Mar 03 2021 at 18:10)</a>:</h4>
<p>I'm currently taking that sledgehammer further by (probably) breaking the compiler by having it not do draining to <code>outlives_predicates</code> at all, but it compiled, and it compiled that program. Now i'm just investigating the different debug outputs as i go. So far, it's not proving much of anything, so i'll have to look further.</p>



<a name="228683124"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/228683124" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jonathan de Jong <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#228683124">(Mar 03 2021 at 22:51)</a>:</h4>
<p>I'm slowly starting to understand how subtle this bug seems to be, removing <code>outlives_predicates</code> didn't seem to do anything, unfortunately.</p>



<a name="229115642"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/229115642" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jonathan de Jong <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#229115642">(Mar 06 2021 at 17:48)</a>:</h4>
<p>Ive narrowed it further down, i have a comparison between <span class="user-mention" data-user-id="117366">@Tatsuyuki Ishi</span>'s <a href="https://github.com/ishitatsuyuki/rust/tree/nodup">branch</a> and current latest (<code>51748a8fc77283914d4135f31b5966a407208187</code>), and while ishi's branch <em>does</em> seem to re-introduce <a href="https://github.com/rust-lang/rust/issues/43787">#43787</a>, it also reduces this issue from it's exponential standpoint.</p>
<p>You can try the following 3 patches on <code>51748a</code> to see the performance differences, i'll explain how to apply these in a moment.</p>
<p>The first patch adds some specific verbose logging, some part of the patch provided by <span class="user-mention" data-user-id="266752">@Izzy Swart</span> here, after compilation, you can see a <code>dump</code> file in the compiler's working directory to get some insight into duplicate obligations from a result of <code>normalize_with_depth_to</code>.</p>
<p>But what i'm more interested in is what error output gives after you put the environment variable <code>RUSTC_OBL_DUP=yes</code> after applying the second patch (though not onto the third), which prints if duplicate obligations are found within either the <code>NormalizedTy</code> cache, or if there'd be duplicates between the <code>NormalizedTy.obligations</code> and <code>&amp;mut obligations</code> vec, in the case of the test code, it starts to blow up the amount of duplicate obligations.</p>
<p>The third patch removes this piece of cache altogether, which brings down the performance impact.</p>
<p>First patch: <a href="/user_uploads/4715/zU-HsWrBeBk_ht-H9tBaAen1/add_logging.patch">add_logging.patch</a> </p>
<p>Second patch: <a href="/user_uploads/4715/Cu8OVHM1EwS7lWFa8TpWJUAm/obl_dump.patch">obl_dump.patch</a> </p>
<p>Third patch: <a href="/user_uploads/4715/Q5NXd2z27pBPNcXfIIy_SXwa/nocache.patch">nocache.patch</a> (effectively ishi's branch, but able to be applied onto that commit)</p>
<p>Test code: <a href="/user_uploads/4715/Ydw1jf6LSLlpnnkh8Z9PfjRr/main.rs">main.rs</a> (adjust the dots inside the <code>Test</code> macro at your discretion to get more recursion/explosion, the <code>3 GB</code> isn't accurate for that last piece anymore, remove the commented-out-three dots to make it accurate again)</p>



<a name="229115666"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/229115666" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jonathan de Jong <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#229115666">(Mar 06 2021 at 17:48)</a>:</h4>
<p>(i may or may not have messed up some of the patches to align with the commit in the right orders, but i hope their intention is kinda clear)</p>



<a name="229115795"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/229115795" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jonathan de Jong <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#229115795">(Mar 06 2021 at 17:50)</a>:</h4>
<p>I also have a log file generated from <code>obl_dump</code>'s output for <code>main.rs</code>: <a href="/user_uploads/4715/1qmnFXTj5FfeK6TjV1zuK4CL/log.with.dev">log.with.dev</a></p>
<p>as you can see, it starts blowing up very quickly for some reason, the <code>&gt;\d+</code> numbers is <code>depth</code> as given by the function parameters</p>



<a name="229116179"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/229116179" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jonathan de Jong <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#229116179">(Mar 06 2021 at 17:56)</a>:</h4>
<p><span class="user-mention" data-user-id="116009">@nikomatsakis</span> this is somewhat your area of expertise, i've seen you comment on many of the original PRs that i encountered along the way trying to resolve this. Given this information, can you comment on this issue a little?</p>



<a name="229124464"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/229124464" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jonathan de Jong <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#229124464">(Mar 06 2021 at 20:00)</a>:</h4>
<p>(correction: <a href="https://github.com/rust-lang/rust/issues/43132">#43132</a>, not <a href="https://github.com/rust-lang/rust/issues/43787">#43787</a> in the message above)</p>
<p>I think i fixed the issue.</p>
<p>Thinking about <a href="https://github.com/rust-lang/rust/issues/43132">#43132</a> (and the <a href="https://github.com/rust-lang/rust/blob/66211f6657971bdaf18996400435b6a416aa3343/compiler/rustc_trait_selection/src/traits/project.rs#L520-L530">comment</a> made on it), and ishi's branch which removes this piece of code, and thereby fixing the issue, I took a shot in the dark and changed</p>
<div class="codehilite" data-code-language="Rust"><pre><span></span><code><span class="n">obligations</span><span class="p">.</span><span class="n">extend</span><span class="p">(</span><span class="n">ty</span><span class="p">.</span><span class="n">obligations</span><span class="p">);</span><span class="w"></span>
</code></pre></div>
<p>to</p>
<div class="codehilite" data-code-language="Rust"><pre><span></span><code><span class="n">obligations</span><span class="p">.</span><span class="n">extend</span><span class="p">(</span><span class="n">ty</span><span class="p">.</span><span class="n">obligations</span><span class="p">.</span><span class="n">iter</span><span class="p">().</span><span class="n">filter_map</span><span class="p">(</span><span class="o">|</span><span class="n">o</span><span class="o">|</span><span class="w"></span>
<span class="w">  </span><span class="k">if</span><span class="w"> </span><span class="kd">let</span><span class="w"> </span><span class="n">rustc_middle</span>::<span class="n">ty</span>::<span class="n">PredicateKind</span>::<span class="n">Trait</span><span class="p">(</span><span class="o">..</span><span class="p">)</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">o</span><span class="p">.</span><span class="n">predicate</span><span class="p">.</span><span class="n">inner</span><span class="p">.</span><span class="n">kind</span><span class="p">.</span><span class="n">skip_binder</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="nb">Some</span><span class="p">(</span><span class="n">o</span><span class="p">.</span><span class="n">clone</span><span class="p">())</span><span class="w"> </span><span class="p">}</span><span class="w"> </span><span class="k">else</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="nb">None</span><span class="w"> </span><span class="p">}</span><span class="w"></span>
<span class="p">));</span><span class="w"></span>
</code></pre></div>
<p>Only allowing <code>Trait</code>-related predicates in the cache.</p>
<p>This seems to fix the issue as denoted by <a href="https://github.com/rust-lang/rust/issues/43132#issuecomment-313933159">the minimalized code</a> (as the original code compiled fine on latest), and going further (with the same <code>src/main.rs</code> above), it seems to fix that issue as well, being able to add as many nestings as i want, and it only linearly scaling (instead of exponentially).</p>
<p>I'm wary to introduce this change, this is very hotch-potch, i do not have in-depth knowledge of the intricacies of what i'm playing with here, and I really want someone else to verify this fix before we go apply it to the codebase, because unless im <em>very</em> lucky, i don't believe this is all there was to fix (for this to work and not cause any further ICEs)</p>



<a name="229128583"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/229128583" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jonathan de Jong <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#229128583">(Mar 06 2021 at 20:57)</a>:</h4>
<p>Poking further, <code>Projection</code> also seems to pass <a href="https://github.com/rust-lang/rust/issues/43132">#43132</a>, however, this seems to reactivate the issue again.</p>
<p>I also tried <code>Projection(..) =&gt; None, _ =&gt; Some(o.clone())</code>, but interestingly enough, this seems to reactivate <a href="https://github.com/rust-lang/rust/issues/43132">#43132</a> again, i'm currently trying to figure out how this happens.</p>



<a name="229129621"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/229129621" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jonathan de Jong <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#229129621">(Mar 06 2021 at 21:12)</a>:</h4>
<p>Okay, after that last message, i went back and tested my first solution again, and... it doesn't work anymore? I think i'm either encountering a slightly-older version of my compiled <code>rustc</code> being used for the moment, or a mistype, or anything inbetween.</p>



<a name="229130018"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/229130018" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jonathan de Jong <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#229130018">(Mar 06 2021 at 21:19)</a>:</h4>
<p>Messing around a little bit, <code>Projection(..)</code> seems to fix <a href="https://github.com/rust-lang/rust/issues/43132">#43132</a>, but like noted above, triggers the performance issue, at this point i don't really know how to start fixing it, or on what ends i could potentially filter this better, or where to look now.</p>
<p>Thus, this issue is not fixed, sorry, i seem to have gotten faulty results.</p>



<a name="229421838"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/229421838" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Izzy Swart <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#229421838">(Mar 09 2021 at 04:50)</a>:</h4>
<p>did some more investigating. <span class="user-mention" data-user-id="216206">@lcnr</span>'s minimization compiles on nightly w/ Ishi's patch applied while the original minimization still does not, so it unfortunately doesn't preserve reproduction. this has manifested in a variety of different confusing ways in edge-case scenarios, but fundamentally they all happen in associated type normalization and boil down to the creation of a huge stream of duplicate predicates and weird duplicate inference variables. This seems directly related to the comment made <a href="https://github.com/rust-lang/rust/blob/0148b971c921a0831fbf3357e5936eec724e3566/compiler/rustc_trait_selection/src/traits/project.rs#L480">here</a> about issue <a href="https://github.com/rust-lang/rust/issues/20304">#203040</a>. I'm not sure why I thought there was something else more nuanced going on here, I must have noticed this comment at some point and maybe glossed over it? Seems pretty directly relevant to the behavior I'm observing. I'd love to fix this but I don't really know what the relevant sort of "ambiguity" that's being discussed here is,  why it leads to normalizing about a dozen straightforward projections down to literally millions of obligations, etc. Maybe <span class="user-mention" data-user-id="116009">@nikomatsakis</span> can comment on this?</p>



<a name="229422120"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/229422120" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Izzy Swart <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#229422120">(Mar 09 2021 at 04:54)</a>:</h4>
<p>for what it's worth "seems directly related" can probably be stated a bit more strongly: it's clear from extensive profiling and investigation of a few different examples that I previously thought were different issues that they all boil down to the accumulation of these presumably-spurious duplicate obligations during the normalization process, sp. in opt_normalize_projection_type and recursion from there. this naturally comes up in selection, item wf checking, mir borrowck in one case even, but the underlying issue is the same, which in a way returns us to square one where there was one isolated issue related to the duplication of obligations.</p>



<a name="229555583"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/229555583" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nikomatsakis <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#229555583">(Mar 09 2021 at 21:16)</a>:</h4>
<p><span class="user-mention" data-user-id="300259">@Jonathan de Jong</span> sorry for not responding yet! let me read over this a bit</p>



<a name="229555595"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/229555595" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nikomatsakis <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#229555595">(Mar 09 2021 at 21:16)</a>:</h4>
<p>or <span class="user-mention" data-user-id="266752">@Izzy Swart</span></p>



<a name="229569482"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/investigating%20obligations%20blowup/near/229569482" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jonathan de Jong <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/investigating.20obligations.20blowup.html#229569482">(Mar 09 2021 at 22:41)</a>:</h4>
<p>No worries, thanks for taking the time to look at this problem at all :D</p>



<hr><p>Last updated: Aug 07 2021 at 22:04 UTC</p>
</html>